#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
@Project ：PythonData 
@File    ：DataClass.py
@Author  ：朱志文
@Date    ：2021/10/3 17:25
数据类型
'''
import sys

'''
字符串的使用 
- 计算长度 
- 下标运算 
- 切片 
- 常用方法'''
#
# str = 'hello world!'
# str2 = 'Python3'
#
# '''通过内置函数len计算字符的长度'''
# print(len(str))  # 12
#
# '''从字符串中查找子串所在位置'''
# print(str.find('or'))  # 7
# print(str.find('shit'))  # -1 不存在返回
#
# '''与find类似但找不到字串时会引发异常'''
# # print(str.index('or')) # 7
# # print(str.index('shit')) # 异常
#
# '''字符串切片(从指定的开始索引到指定的结束索引)'''
# print(str[1:3])  # el
# print(str[:3])  # hel
# print(str[3:])  # lo world!
# print(str[1::3])  # eood
# print(str[::3])  # hlwl
# print(str[3::])  # lo world!
#
# '''常用方法'''
# # 字符串首字母大写
# print(str.capitalize())  # Hello,world!
# # 字符串每个首字母大写
# print(str.title())  # Hello World!
# # 字符串都小写
# print(str.lower())  # hello world!
# # 字符串都大写
# print(str.upper())  # HELLO WORLD!
# # 字符串子串替换
# print(str.replace('hello', 'python'))  # python world!
# # 计算字串在字符串出现的次数
# print(str.count('el'))  # 1
# # 获得字符串修剪左右两侧空格之后的拷贝
# print(str.strip())  # hello world!
# # 检查字符串是否由数字构成
# print(str2.isdigit())  # False
# # 检查字符串是否以字母构成
# print(str2.isalpha())  # False
# # 检查字符串是否以数字和字母构成
# print(str2.isalnum())  # True

'''定义列表 / 用下表访问元素 / 下标越界 / 添加元素 / 删除元素 / 修改元素 / 切片 / 循环遍历'''

# '''列表的定义'''
# list=[1024,0.5,'Python']
#
# '''用下表访问元素'''
# print(list[0]) # 1024
# print(list[1:]) # [0.5, 'Python']
#
# '''下标越界'''
# # print(list[5]) #报错
#
# '''添加元素'''
# list.append('Hello World!')
# list.insert(1,400)
# print(list) # [1024,400, 0.5, 'Python', 'Hello World!']
#
# '''删除元素'''
# del list[2]
# list.pop(1)
# list.remove('Python')
# print(list) # [1024']
#
# '''修改元素'''
# list[1]=5
# print(list) # [1024, 5, 'Hello World!']
#
# '''切片'''
# print(list[1:2]) # [5]
# # 可以通过完整切片操作来复制列表
# print(list[:]) # [1024, 5, 'Hello World!']
# print(list[-2:-1]) # [5]
# # 可以通过反向切片操作来获得倒转后的列表的拷贝
# print(list[::-1]) # ['Hello World!', 5, 1024]
#
# '''循环遍历'''
# # 通过循环用下标遍历列表元素
# for index in range(len(list)):
#     print(list[index],end=' ') # 1024 5 Hello World!
# # 通过循环用下标遍历列表元素
# for value in list:
#     print(value,end=" ")# 1024 5 Hello World!

'''列表常用操作 - 连接 / 复制(复制元素和复制数组) / 长度 / 排序 / 倒转 / 查找'''
# list=[1,3,5,7,100]
# '''连接'''
# list.extend([105,133])
# print(list)
# '''复制(复制元素和复制数组)'''
#
#
#
# listCopy=list.copy()
# print(listCopy)
# '''长度'''
# print(len(list))
# '''排序'''
# # list.sort(reverse=True)
# # print(list)
# print(sorted(list)) # [1, 3, 5, 7, 100, 105, 133]
# print(sorted(list,reverse=True)) #reverse = True 降序 ， reverse = False 升序（默认） [133, 105, 100, 7, 5, 3, 1]
# '''倒转'''
# list.reverse()
# print(list) #[133, 105, 100, 7, 5, 3, 1]
# '''查找'''
# print(list.index(3)) #5
# # 清空列表元素
# list.clear()
# print(list) # []

'''使用range创建数字列表 / 生成表达式 / 生成器'''
# f = [x for x in range(1, 10)]
# print(f)
# f = [x + y for x in 'ABCDE' for y in '1234567']
# print(f)
# # 用列表的生成表达式语法创建列表容器
# # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
# f = [x ** 2 for x in range(1, 1000)]
# print(sys.getsizeof(f))  # 查看对象占用内存的字节数
# print(f)
# # 请注意下面的代码创建的不是一个列表而是一个生成器对象
# # 通过生成器可以获取到数据但它不占用额外的空间存储数据
# # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
# f = (x ** 2 for x in range(1, 1000))
# print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
# print(f)
# for val in f:
#     print(val)

'''元组的使用 - 定义元组 / 使用元组中的值 / 修改元组变量 / 元组和列表转换'''
#
# '''定义元组'''
# t=(1024,0.5,'Python')
#
# '''使用元组中的值'''
# print(t[0]) # 1024
# print(t[1:]) # (0.5, 'Python')
#
# '''修改元组变量 元组中元素不能被修改，我们要用重新赋值的方式操作'''
# t=(1024,0.5,'Python','Hello World!')
# print(t) # (1024, 0.5, 'Python', 'Hello World!')
#
# '''元组和列表转换'''
# list=list(t)
# print(list)
#
# '''删除元组 元组中的元素不能被删除，我们只能删除整个元组'''
# del t
# print(t)

'''字典的基本用法 - 字典的特点 / 创建字典 / 添加元素 / 删除元素 / 取值 / 清空'''

'''字典的特点'''
'''字典是另一种可变容器模型，Python中的字典跟我们生活中使用的字典是一样一样的，它可以存储任意类型对象，
与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。'''

# '''创建字典'''
# # 方式一
# d1 = {'name': '小明', 'age': 18}
# print('name:{name}, age:{age}'.format(name=d1['name'], age=d1['age']))  # name:小明, age:18
# # 方式二
# list = [('name', '小明'), ('age', 18)]
# d2 = dict(list)
# print(d2)  # {'name': '小明', 'age': 18}
# # 方式三
# d3 = dict(name='小明', age=18)
# print(d3)  # {'name': '小明', 'age': 18}
# '''添加元素'''
# d1['sex'] = '男'
# print(d1['sex'])  # 男
# '''删除元素'''
# d1.pop('sex', '男')
# print(d1)
# '''更新元素'''
# d1['age'] = 20
# print(d1)  # {'name': '小明', 'age': 20}
# d2.update(sex='男')
# print(d2)  # {'name': '小明', 'age': 18, 'sex': '男'}
# '''取值'''
# print(d3.get('age')) #18
# '''清空'''
# d1.clear()
# print(d1) # {}

'''字典常用操作 - keys()方法 / values()方法 / items()方法 / setdefault()方法'''
# d={'小明':12,'小红':20}
# '''key()方法'''
# print(d.keys()) # dict_keys(['小明', '小红'])
# '''values()方法'''
# print(d.values()) # dict_values([12, 20])
# '''items()方法'''
# print(d.items()) # dict_items([('小明', 12), ('小红', 20)])
# '''setdefault()方法'''
# print(d.setdefault("小明",None)) # 12
# print(d.setdefault("小方",20)) # 20
# print(d) # {'小明': 12, '小红': 20, '小方': 20}

'''集合基本用法 - 集合和列表的区别 / 创建集合 / 添加元素 / 删除元素 / 清空'''

# '''集合和字典的区别'''
# '''集合（set）与字典相同均存储 key，但也只存储 key，因 key 不可重复，所以 set 的中的值不可重复，也是无序的。'''
#
# '''集合和列表的区别'''
#
# '''创建集合'''
# s1={'a','b','c'}
# s2=set(['a','b','c'])
# s3=set(['a', 'a', 'b', 'c', 'c'])
# print(s1) # {'c', 'b', 'a'}
# print(s2) # {'c', 'b', 'a'}
# print(s3) # {'c', 'b', 'a'}
# '''添加元素'''
# s1.add('d')
# s2.update('e')
# print(s1) # {'a', 'c', 'd', 'b'}
# print(s2) # {'a', 'c', 'b', 'e'}
# '''删除元素'''
# s3.remove('c')
# print(s3) # {'b', 'a'}
# '''清空'''
# s3.clear()
# print(s3) # set()
# '''长度'''
# print(len(s1))

'''集合常用操作 - 交集 / 并集 / 差集 / 对称差 / 子集 / 超集'''
set1 = {'a', 'b', 'c'}  # {'c'}
set2 = {'d', 'e', 'c', 'a', 'b'}  # {'c'}
'''交集'''
print(set1 & set2)  # {'b', 'd', 'a', 'e', 'c'}
print(set1.intersection(set2))  # {'b', 'd', 'a', 'e', 'c'}

'''并集'''
print(set1 | set2)  # {'a', 'b'}
print(set1.union(set2))  # {'d', 'e'}

'''差集'''
print(set1 - set2)  # {'d', 'b', 'e', 'a'}
print(set2.difference(set1))  # {'d', 'b', 'e', 'a'}

'''对称差'''
print(set1 ^ set2)
print(set1.symmetric_difference(set2))

'''超集'''
'''判断子集和超集'''
# 子集
print(set2 <= set1)  # False
print(set2.issubset(set1))  # False
# 超集
print(set2 >= set1)  # True
print(set2.issuperset(set1))  # True
